#!/bin/bash
################################################################
# Ejecutable: postular.sh													#
#																					#
# Precondiciones: se ejecutó ./postini.sh con anterioridad  	#
#						hay archivos para procesar en /recibidos		#
#																					#
# Postcondiciones: Los archivos procesado quedan en /procesados#
#						Los registros procesados y los erroneos		#
#						quedan en sendos archivos en /nuevos			#
################################################################

#La variable de entorno que contiene el "grupoXX" es $grupo (con minusculas)
GRUPO=$grupo


# Variables del script
LOGGER=$BINDIR"/gralog.sh"
CARPETA_RECIBIDOS=$GRUPO"/recibidos"
ARCH_AGENCIAS=$GRUPO"/data/agencias.mae"
ARCH_BENEFICIOS=$GRUPO"/data/beneficios.mae"
CARPETA_NUEVOS=$GRUPO"/nuevos"
CARPETA_PROCESADOS=$GRUPO"/procesados"

#LISTA DE CAMPOS OBLIGATORIOS EN EL ORDEN QUE TIENEN QUE APARECER EN EL REGISTRO
LISTA_CAMPOS_OBLIGATORIOS="BENEFICIO CUIL TIPODOC NUMERODOC APELLIDO NOMBRE DOMICILIO LOCALIDAD PROVINCIA"

# Array de expresiones regulares asociadas a cada campo obligatorio
array_exp_reg=( "^[a-zA-Z0-9]\{5\}$" "^[0-9]\{11\}*$" "^[DU|LC|LE|PA]\{2\}$" "^[a-zA-Z0-9]\{9\}$" "^[a-zA-Z0-9]*$" "^[a-zA-Z0-9]*$" "^[a-zA-Z0-9 ]*$" "^[a-zA-Z0-9 ]*$" "^[a-zA-Z0-9 ]*$" )
	
#VARIABLES GLOBALES USADAS PARA LA VALIDACION DE LA INFORMACION EN LOS CAMPOS
#DE LOS REGISTROS DEL ARCHIVO DE POSTULANTES
FIB_TMP=""
FFB_TMP=""
DMB_TMP=""

otraInstanciaCorriendo(){
	MI_PID=$$
	MI_NOMBRE=$0
	OTROS=`ps -A |grep  "$MI_NOMBRE" |grep -v "grep" |grep -v "$MI_PID"|wc -l  `	
    	if [ $OTROS != "0" ]; then
        	return 1
    	fi
	return 0
}	

chequearAmbiente(){

	if [ -z $GRUPO ]
	then
		return 1
	fi
	if [ -z $BINDIR ]
	then
		return 1
	fi
	
	return 0
}

inicializarLogger(){
	# Grabamos mensaje de log
	`$LOGGER postular "Iniciando POSTULAR. Cantidad de archivos: $1" I`
}

emitirRegistroProcesado(){
	local NOMBRE_ARCH=$1
	local CAMPOS_OBLIG=$2
	local CAMPOS_FECHAS=$3
	local CAMPOS_ESTADO=$4
	local FECHA_CORRIENTE=$5

	###CALCULOS
	#la variable que contenga el valor del usuario actual segun el ambiente
	local USUARIO=$USER
	#la fecha actual

	local AGENCIA=`echo "$NOMBRE_ARCH" | sed 'sa.*/\(.*\)\.[0-9]*$a\1a'`
	local SECUENCIA=`echo "$NOMBRE_ARCH" | sed 'sa.*/.*\.\([0-9]*\)$a\1a'`
	local MIPID=$$
	local ARCHIVO_SALIDA="$CARPETA_NUEVOS/benef.$MIPID"

	
	#local ARCHIVO_ERROR="$CARPETA_NUEVOS/benef.$MIPID"
	#emitirErrorRegistro "$ARCHIVO" "$POS" "FORMATO DE REGISTRO ERRONEO" "$REGISTRO"

	
#TODO: Cual es el destino de los archivos de error de los procesados?

#TODO: Chequear si el archivo existe y ver que nombre ponerle o si se acumulan si ya existe?
	echo "$AGENCIA,$SECUENCIA,$CAMPOS_OBLIG,$CAMPOS_FECHAS,$CAMPOS_ESTADO,$USUARIO,$FECHA_CORRIENTE" >> $ARCHIVO_SALIDA
}

obtenerDatosBeneficio(){
	local BENEFICIO=$1

	FIB_TMP=""
	FFB_TMP=""
	DMB_TMP=""
	local REG_BENEFICIO=`grep "^[0-9]\{3\},$BENEFICIO,[0-9]\{4\}-[01][0-9]-[0-3][0-9],[0-9]\{4\}-[01][0-9]-[0-3][0-9],[0-9]*,.**$" "$ARCH_BENEFICIOS" `
	
	if [ -z "$REG_BENEFICIO" ]
	then
		return 1
	else
		FIB_TMP=`echo "$REG_BENEFICIO" | cut -d , -f 3 `
		FFB_TMP=`echo "$REG_BENEFICIO" | cut -d , -f 4 `
		DMB_TMP=`echo "$REG_BENEFICIO" | cut -d , -f 5 `
		return 0
	fi
}

procesarRegistro(){
	local NOMBRE_ARCH=$1
	local REG=$2
	local FIB=$3
	local FFB=$4
	local DMB=$5
	local CAMPOS_OBLIGATORIOS=`echo "$REG" | cut -d , -f 1-9`
	local FPA=`echo "$REG" | cut -d, -f 10`
	local DUR=`echo "$REG" | cut -d, -f 11`

	local FC=`date +"%Y-%m-%d"`

	local FEA=$FPA
	local ERROR_VALIDACION_CAMPOS=0
	local ESTADO="F"
	local MOTIVO="SIN MOTIVO"
	if [ "$FPA" \< "$FC" ]
	then
		if [ "$FC" \< "$FIB" ]
		then
			FEA=$FIB
		else
			FEA=$FC
		fi
	else
		if [ "$FPA" \< "$FIB" ]
		then
			FEA=$FIB
		fi
	fi
	
	if [ -z "$DUR" ]
	then
		DUR=$DMB
	fi

	if [ $ERROR_VALIDACION_CAMPOS -eq 1 ]
	then
		ESTADO="R"
		#TODO:esto hay que detectar el mensaje exacto , este mensaje que pongo no va
		MOTIVO="LA VALIDACION A NIVEL DE DATOS DE CAMPOS FALLO"
	else
		if [ "$FEA" == "$FC" ]

		then
			ESTADO="A"
			MOTIVO="LA FECHA EFECTIVA DE ALTA COINCIDE CON LA FECHA ACTUAL"
		elif [ "$FEA" \> "$FC" ]
		then
			ESTADO="P"
			MOTIVO="LA FECHA EFECTIVA DE ALTA ES MAYOR A LA FECHA ACTUAL"
		fi
	fi
			
	local MES=`echo "$FEA" | cut -d - -f 2`
	local ANIO=`echo "$FEA" | cut -d - -f 1`
	local FF_DIA=`echo "$FEA" | cut -d - -f 3`

	local FF_MES=`echo "($MES + $DUR) % 12 " | bc `
	local FF_ANIO=`echo "((($MES + $DUR) / 12) + $ANIO) " | bc `
	local FF="$FF_ANIO-$FF_MES-$FF_DIA"
	if [ "$FF" \> "$FFB" ]
	then
		FF=$FFB
	fi

	emitirRegistroProcesado "$NOMBRE_ARCH" "$CAMPOS_OBLIGATORIOS" "$FPA,$FEA,$DUR,$FF" "$ESTADO,$MOTIVO" "$FC"
}

chequearFecha(){
	local FECHA=$1
	local FMT_NUMERICO=`echo "$FECHA" | grep "^[0-9]\{4\}-[01][0-9]-[0-3][0-9]$" `
	if [ -z $FMT_NUMERICO ]
	then
		return 1
	fi
	local ANIO=`echo "$FECHA" | cut -d - -f 1`
	local MES=`echo "$FECHA" | cut -d - -f 2`
	local DIA=`echo "$FECHA" | cut -d - -f 3`

	if [ "$MES" -gt 12 ] || [ "$MES" -le 0 ]
	then
		return 1
	fi
	
	if [ "$DIA" -gt 31 ] || [ "$DIA" -le 0 ]
	then
		return 1
	fi

	#TODO: aca faltarian los chequeos de anio y los chequeos de mes vs dia  y de anios bisiestos
	return 0
}

validarInformacionCampos(){
	local NOMBRE_ARCH=$1
	local REG=$2

	local AGENCIA=`echo "$NOMBRE_ARCH" | sed 'sa.*/\(.*\)\.[0-9]*$a\1a'`
	local SECUENCIA=`echo "$NOMBRE_ARCH" | sed 'sa.*/.*\.\([0-9]*\)$a\1a'`

	local ESTADO=""
	local MOTIVO=""
	local FC=`date +"%Y-%m-%d"`
	local CAMPOS_OBLIGATORIOS=`echo "$REG" | cut -d , -f 1-9 `
	local BENEF=`echo "$REG" | cut -d , -f 1 `
	local FPA=`echo "$REG" | cut -d , -f 10 `
	local DUR=`echo "$REG" | cut -d , -f 11 `
	obtenerDatosBeneficio $BENEF
	RESP=$?
	if [ "$RESP" -eq 1 ]
	then
		ESTADO="R"
		MOTIVO="NO EXISTE EL BENEFICIO"	
		DUR=0
		emitirRegistroProcesado "$NOMBRE_ARCH" "$CAMPOS_OBLIGATORIOS" "$FPA,$FC,$DUR,$FC" "$ESTADO,$MOTIVO" "$FC"
		return 1
	fi

	chequearFecha $FPA
	RESP=$?
	if [ "$RESP" -eq 1 ]
	then
		ESTADO="R"
		MOTIVO="FPA INVALIDA"	
		DUR=0
		emitirRegistroProcesado "$NOMBRE_ARCH" "$CAMPOS_OBLIGATORIOS" "$FPA,$FC,$DUR,$FC" "$ESTADO,$MOTIVO" "$FC"
		return 2
	fi

	if [ "$FPA" \> "$FFB_TMP" ]
	then
		ESTADO="R"
		MOTIVO="FPA MAYOR A FFB"	
		DUR=0
		emitirRegistroProcesado "$NOMBRE_ARCH" "$CAMPOS_OBLIGATORIOS" "$FPA,$FC,$DUR,$FC" "$ESTADO,$MOTIVO" "$FC"
		return 3
	fi

	if [ -z "$DUR" ]
	then
		DUR="$DMB_TMP"
	fi
	
	if [ "$DUR" -gt "$DMB_TMP" ]
	then
		ESTADO="R"
		MOTIVO="DURACION MAYOR A DMB"	
		DUR=0
		emitirRegistroProcesado "$NOMBRE_ARCH" "$CAMPOS_OBLIGATORIOS" "$FPA,$FC,$DUR,$FC" "$ESTADO,$MOTIVO" "$FC"
		return 4
	fi

	return 0
}

emitirErrorRegistro(){
	local NOMBRE_ARCH=$1
	local NRO_REG=$2
	local MOTIVO=$3
	local REG=$4

	local AGENCIA=`echo "$NOMBRE_ARCH" | sed 'sa.*/\(.*\)\.[0-9]*$a\1a'`
	local SECUENCIA=`echo "$NOMBRE_ARCH" | sed 'sa.*/.*\.\([0-9]*\)$a\1a'`

	local MIPID=$$

	local ARCHIVO_SALIDA_ERRORES="$CARPETA_NUEVOS/benerro.$MIPID"
	
#TODO: Cual es el destino de los archivos de error de los procesados?

	echo "$AGENCIA,$SECUENCIA,$NRO_REG,$MOTIVO,\"$REG\"" >> $ARCHIVO_SALIDA_ERRORES
}

##6.- Validad a nivel de campo
validarCamposObligatorios(){
	local FILE=$1
	local NRO_REG=$2
	local REG=$3
	local i=0
	local PREV2_IFS=$IFS

	IFS=" "

	for CAMPO in $LISTA_CAMPOS_OBLIGATORIOS
	do
		i=`echo "$i +1 " |bc  `
		local VALOR=`echo "$REG" | cut -d , -f "$i"`
		#echo "El campo:$CAMPO tiene el valor: $VALOR"

		TIPO_OBLIGATORIO=`echo "$VALOR" | grep "${array_exp_reg[(($i-1))]}"`
		
		if [ -z "$TIPO_OBLIGATORIO" ]
		then
			#echo "El campo:$CAMPO no cumple formato: $VALOR"
			IFS=$PREV2_IFS
			emitirErrorRegistro "$FILE" "$NRO_REG" "CAMPO $CAMPO NO INFORMADO" "$REG"

			return 1
		fi
	done
	IFS=$PREV2_IFS
	return 0
}

##5.- Validar a nivel de registro
# Chequeo por la cantidad de campos a ver si tiene la cantidad obligatoria, 
# 1 campo opcional o 2 campos opcionales o cantidad incorrecta.
validarCantidadCampos(){
	local REGISTRO=$1
	local SOLO_OBLIG=`echo "$REGISTRO" | grep "^[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,[^,]*$" `
	if [ $SOLO_OBLIG ]
	then
		return 0
	fi

	local UN_OPCIONAL=`echo "$REGISTRO" | grep "^[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,[^,]*$" `
	if [ $UN_OPCIONAL ]
	then
		return 1
	fi
	local DOS_OPCIONAL=`echo "$REGISTRO" | grep "^[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,[^,]*$" `
	if [ $DOS_OPCIONAL ]
	then
		return 2
	fi
	
	return 99
}

procesarArchivo(){
	ARCHIVO=$1	
	#solo toma los campos obligatorios, cuando tiene los opcionales no entra, hacer otros grep
	#excluyentes a este para hacer el chequeo

	local NUM_REGISTROS=0
	local REG_ERRONEOS=0
	local REG_VALIDOS=0
	
	REGS=`cat $ARCHIVO`
	local PRE_IFS=$IFS
	IFS="
"
	local POS=0

	for REGISTRO in $REGS
	do
		let NUM_REGISTROS=$NUM_REGISTROS+1	
	
		ERROR_CAMPOS_OBLIG=1
		POS=`echo "$POS +1 " |bc  `
		
		##5.- Validar a nivel de registro	

		validarCantidadCampos "$REGISTRO"
		local CANTIDAD_CAMPOS_OPC=$?
		if [ $CANTIDAD_CAMPOS_OPC -eq 99  ]
		then
			emitirErrorRegistro "$ARCHIVO" "$POS" "FORMATO DE REGISTRO ERRONEO" "$REGISTRO"
			let REG_ERRONEOS=$REG_ERRONEOS+1
			continue
		fi
		
		validarCamposObligatorios "$ARCHIVO" "$POS" "$REGISTRO"
		local ERROR_CAMPOS_OBLIG=$?
		
		##Si algun campo obligatorio falta , ya se emitio el mensaje de error .
		if [ $ERROR_CAMPOS_OBLIG -eq 0 ]
		then
			if [ $CANTIDAD_CAMPOS_OPC -eq 0 ]
			then
				local FECHA_ACTUAL=`date +"%Y-%m-%d"`
				REGISTRO=$REGISTRO",$FECHA_ACTUAL,"
			elif [ $CANTIDAD_CAMPOS_OPC -eq 1 ]
			then
				REGISTRO=$REGISTRO","	
			fi
			validarInformacionCampos "$ARCHIVO" "$REGISTRO"
			local ERROR_DATOS=$?
			if [ "$ERROR_DATOS" -eq 0 ]
			then
				procesarRegistro "$ARCHIVO" "$REGISTRO" "$FIB_TMP" "$FFB_TMP" "$DMB_TMP"
				let REG_VALIDOS=$REG_VALIDOS+1
			else
				let REG_ERRONEOS=$REG_ERRONEOS+1
			fi
			continue
		else
			let REG_ERRONEOS=$REG_ERRONEOS+1

		fi	
	done
	IFS=$PRE_IFS
	
#	let REG_ERRONEOS=$NUM_REGISTROS-$REG_VALIDOS

	`$LOGGER postular "Cantidad Total de registros: $NUM_REGISTROS" I`
	`$LOGGER postular "Cantidad de registros con error $REG_ERRONEOS" I`
	`$LOGGER postular "Cantidad de beneficiarios nuevos $REG_VALIDOS" I`
}

main(){
#Pasos Sugeridos



##1.- Ver si existe otro postular corriendo
	otraInstanciaCorriendo
	EXIST=$?
	if [ $EXIST != "0" ]
	then
		echo "Error: Existe otra instancia ejecutandose de $0"
		exit 1
	fi

##2.- Ver si se inicializo el ambiente
	chequearAmbiente
	INICIALIZADO=$?
	if [ $INICIALIZADO != "0" ]
	then
		echo "Error: El ambiente no esta correctamente inicializado."
		exit 2
	fi

##3.- Inicializar el Log
	# Contamos la cantidad de archivos a procesar
	array=( `ls -1X $CARPETA_RECIBIDOS` )
	CANTIDAD=${#array[@]}
	inicializarLogger $CANTIDAD
	echo "Se inicia el proceso postular. Archivos a procesar: $CANTIDAD"

##4.- Ubicar archivo a processar
	FILES=`ls -1X $CARPETA_RECIBIDOS`
	for F in $FILES
	do
		if [ -r "$CARPETA_RECIBIDOS/$F" ]
		then
			NOMBRE_SIMPLE=`echo "$F" | sed 'sa.*/\(.*\)$a\1a'`

			echo "Procesando: $NOMBRE_SIMPLE ..."
			
			`$LOGGER postular "Archivo a procesar: $NOMBRE_SIMPLE" I`
			##5 Validar registro y ##6 Validar campos			
			procesarArchivo "$CARPETA_RECIBIDOS/$F"
		else
			`$LOGGER postular "El archivo $F no se pudo abrir." E`
		fi
		
	#TODO mover el archivo procesado otro lugar 
	##7.- Finalizar procesamiento del archivo		
	res=`$BINDIR/mover.sh "$CARPETA_RECIBIDOS/$F" "$CARPETA_PROCESADOS/$F"`
	
	##8.- Seguir con el siguiente archivo		
	done

##9.- Cerrar el Log
	`$LOGGER postular "Fin del proceso postular. PID:$$" I`
	
	echo "POSTULAR PID:$$"
}

main
